#include "struttura_dati.h"
#include <iostream>
#include <fstream>
#include <cstring>
#include <stdlib.h>

using namespace std;

extern partita_t partita;

/** Carica i nomi delle carte dal file e li mette nel campo mazzo[].carta[].
 */
static void carica_file(){
	D1(cout<<"INIZIO DEBUG carica_file"<<endl);
	ifstream f(NOME_FILE);
	
   if (!f) {
		cout<<"Errore in apertura del file "<<NOME_FILE<<endl ;
		}
	
	for(int i=0; i<NUM_CARTE; i++){
		int j=0;
		while(j<MAX_LUN_RIGA1){
			f>>partita.mazzo[i].nome[j];
			j++;
			}
		partita.mazzo[i].nome[j] = '\0';
		}
	D1(cout<<"FINE DEBUG CARICA FILE"<<endl);
}


/** Funzione che mi genera un array casuale di numeri compresi tra 0 e 39.
 *  Ogni numero ha una corrispettiva carta che mi rappresenta.
 *  0-9   --> denari
 *  10-19 --> spade
 *  20-29 --> bastoni
 *  30-39 --> coppe
 */
static void genera_nemero_carte(){
	D1(cout<<"INIZIO DEBUG genera_numero_carte"<<endl);
	/* vat_aus lo utilizzo come vettore ausiliario per dirmi se ho già oppure no 
	 * la carta, perchè ovviamente non devo avere 2 carte uguali.
	 * In realtà questo array funziona al contrario: mi dice se nella posizione 
    * creata c'è già la carta.
	 */
	bool vet_aus[NUM_CARTE];

	// Inizializza il vet_aus a false: non ho ancora creato nessuna carta
	for(int j=0; j<NUM_CARTE; j++)
		vet_aus[j]=false;
		
	/* In questo for: 
	 * i--> rappresenta il numero e la carta vera e propria
	 * j--> l'indice del vettore del mazzo di carte
	 * Quindi trova un indice compreso tra 0 e 39, e se in quella posizione,
	 * vet_aus è già true allora non lo accetta, altrimenti memorizza la carta i.
	 */
	for(int i=0; i<NUM_CARTE; i++){
		int j=0;
		j=rand()%NUM_CARTE;

		/* Controlla che nella posizione indicata da j non sia già presente 
		 * un'altra carta, e se libera memorizza la carta i.
		 */
		if(vet_aus[j]==false){
			vet_aus[j]=true;
			partita.mazzo[j].val=i;
			}

		/* Altrimenti rimane ancora sulla carta i, perchè non l' ha ancora
		 * memorizzata.
		 */
		else
			i--;

		}
	D1(cout<<"FINE DEBUG GENERA NUMERO CARTE"<<endl);
}

/** Funzione che riordina i nomi delle carte in base al vettore dei valori 
 *  trovato nella funzione genera_numero_carte. Ovvero associa ad ogni valore 
 *  numerico una e una sola carta.
 */
static void genera_nome_carte(){
	D1(cout<<"INIZIO DEBUG genera_nome_carte"<<endl);
	
	// carica i nomi delle carte
	carica_file();	
	D2(cout<<"caricato da file con successo"<<endl);
	/* utilizza un vettore ausiliario per memorizzare temporaneamente i nomi
	 * delle carte
    */
	char aus[NUM_CARTE][MAX_LUN_RIGA2];
	
	// for necessario per comporre il nome (con il percorso) di ogni carta
	for(int i=0; i<NUM_CARTE; i++){
		strcpy(aus[i], partita.mazzo[partita.mazzo[i].val].nome);
		// le immagini delle carte si trovano nella cartella "Carte"
		strcpy(partita.mazzo[partita.mazzo[i].val].nome, "./Carte/");
		strcat(partita.mazzo[partita.mazzo[i].val].nome, aus[i]);
		}
	D2(cout<<"nome con percorso composto correttamente"<<endl);
	/* riordino vero e proprio delle carte in base al vettore trovato in 
	 * genera_numero_carte
	 */

	/* riutilizzo del vettore ausiliare per memorizzare il nome completo di
    * ogni carta, ma questa volta in ordine 
    */
	for(int i=0; i<NUM_CARTE; i++){
		strcpy(aus[i], partita.mazzo[partita.mazzo[i].val].nome);
		aus[i][MAX_LUN_RIGA2]='\0';
		}
	
	// ricopiatura nella struttura
	for(int i=0; i<NUM_CARTE; i++){
		strcpy(partita.mazzo[i].nome, aus[i]);
		}
	D1(cout<<"FINE DEBUG GENERA NOME CARTE"<<endl);
}


/** Funzione che genera il mazzo mescolato.
 */
void genera_mazzo(){
	D1(cout<<"INIZIO DEBUG genera_mazzo"<<endl);
	// genera partita.mazzo[].val
	genera_nemero_carte();
	D2(cout<<"numero carte generato con successo"<<endl);
	// genera partita.mazzo[].nome[].
	genera_nome_carte();
	D2(cout<<"nome carte generato con successo"<<endl);
	D1(cout<<"FINE DEBUG GENERA MAZZO"<<endl);
}




